'use strict';

/**
 * 字典类型服务
 */
const Service = require('egg').Service;

class DictTypeService extends Service {
  /**
   * 创建字典类型
   * @param {Object} dictTypeData - 字典类型数据
   * @return {Promise<Object>} 创建的字典类型
   */
  async create(dictTypeData) {
    const { ctx } = this;
    return ctx.model.DictType.create(dictTypeData);
  }

  /**
   * 查询字典类型列表
   * @param {Object} query - 查询条件
   * @param {Number} page - 页码
   * @param {Number} pageSize - 每页数量
   * @return {Promise<Object>} 字典类型列表和总数
   */
  async list(query = {}, page = 1, pageSize = 10) {
    const { ctx } = this;
    const offset = (page - 1) * pageSize;
    const where = {};

    if (query.name) {
      where.name = { [ctx.Sequelize.Op.like]: `%${query.name}%` };
    }

    if (query.code) {
      where.code = { [ctx.Sequelize.Op.like]: `%${query.code}%` };
    }

    if (query.status !== undefined && query.status !== '') {
      where.status = query.status;
    }

    const { count, rows } = await ctx.model.DictType.findAndCountAll({
      where,
      offset,
      limit: pageSize,
      order: [[ 'create_time', 'DESC' ]],
    });

    return {
      list: rows,
      total: count,
      page,
      pageSize,
    };
  }

  /**
   * 查询单个字典类型
   * @param {string} id - 字典类型ID
   * @return {Promise<Object>} 字典类型信息
   */
  async findById(id) {
    const { ctx } = this;
    return ctx.model.DictType.findByPk(id, {
      include: [
        { model: ctx.model.DictItem, as: 'items', where: { status: true }, order: [[ 'sort', 'ASC' ]] },
      ],
    });
  }

  /**
   * 根据编码查询字典类型
   * @param {String} code - 字典类型编码
   * @return {Promise<Object>} 字典类型信息
   */
  async findByCode(code) {
    const { ctx } = this;
    return ctx.model.DictType.findOne({
      where: { code, status: true },
      include: [
        { model: ctx.model.DictItem, as: 'items', where: { status: true }, order: [[ 'sort', 'ASC' ]] },
      ],
    });
  }

  /**
   * 更新字典类型
   * @param {string} id - 字典类型ID
   * @param {Object} dictTypeData - 更新的字典类型数据
   * @return {Promise<Object>} 更新后的字典类型
   */
  async update(id, dictTypeData) {
    const { ctx } = this;
    const dictType = await ctx.model.DictType.findByPk(id);
    if (!dictType) {
      ctx.throw(404, '字典类型不存在');
    }

    return dictType.update(dictTypeData);
  }

  /**
   * 删除字典类型
   * @param {string} id - 字典类型ID
   * @return {Promise<Boolean>} 是否删除成功
   */
  async destroy(id) {
    const { ctx } = this;
    // 直接使用findByPk查询字典类型，不关联查询字典项
    const dictType = await ctx.model.DictType.findByPk(id);
    if (!dictType) {
      ctx.throw(404, '字典类型不存在');
    }

    // 检查是否有字典项
    const items = await ctx.model.DictItem.count({
      where: { dictTypeId: id },
    });

    if (items > 0) {
      ctx.throw(400, '该字典类型存在字典项，无法删除');
    }

    return dictType.destroy();
  }

  /**
   * 更新字典类型状态
   * @param {string} id - 字典类型ID
   * @param {boolean} status - 状态
   * @return {Promise<Object>} 更新后的字典类型
   */
  async updateStatus(id, status) {
    const { ctx } = this;
    const dictType = await ctx.model.DictType.findByPk(id);
    if (!dictType) {
      ctx.throw(404, '字典类型不存在');
    }

    dictType.status = status;
    return dictType.save();
  }

  /**
   * 获取所有启用的字典类型
   * @return {Promise<Array>} 字典类型列表
   */
  async getAllEnabled() {
    const { ctx } = this;
    return ctx.model.DictType.findAll({
      where: { status: true },
      order: [[ 'create_time', 'DESC' ]],
    });
  }
}

module.exports = DictTypeService;
